home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / compiler / ast.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  56KB  |  1,786 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Python abstract syntax node definitions
  5.  
  6. This file is automatically generated by Tools/compiler/astgen.py
  7. '''
  8. from consts import CO_VARARGS, CO_VARKEYWORDS
  9.  
  10. def flatten(list):
  11.     l = []
  12.     for elt in list:
  13.         t = type(elt)
  14.         if t is tuple or t is list:
  15.             for elt2 in flatten(elt):
  16.                 l.append(elt2)
  17.             
  18.         l.append(elt)
  19.     
  20.     return l
  21.  
  22.  
  23. def flatten_nodes(list):
  24.     return _[1]
  25.  
  26. nodes = { }
  27.  
  28. class Node:
  29.     '''Abstract base class for ast nodes.'''
  30.     
  31.     def getChildren(self):
  32.         pass
  33.  
  34.     
  35.     def __iter__(self):
  36.         for n in self.getChildren():
  37.             yield n
  38.         
  39.  
  40.     
  41.     def asList(self):
  42.         return self.getChildren()
  43.  
  44.     
  45.     def getChildNodes(self):
  46.         pass
  47.  
  48.  
  49.  
  50. class EmptyNode(Node):
  51.     pass
  52.  
  53.  
  54. class Expression(Node):
  55.     nodes['expression'] = 'Expression'
  56.     
  57.     def __init__(self, node):
  58.         self.node = node
  59.  
  60.     
  61.     def getChildren(self):
  62.         return (self.node,)
  63.  
  64.     
  65.     def getChildNodes(self):
  66.         return (self.node,)
  67.  
  68.     
  69.     def __repr__(self):
  70.         return 'Expression(%s)' % repr(self.node)
  71.  
  72.  
  73.  
  74. class Add(Node):
  75.     
  76.     def __init__(self, .2, lineno = None):
  77.         (left, right) = .2
  78.         self.left = left
  79.         self.right = right
  80.         self.lineno = lineno
  81.  
  82.     
  83.     def getChildren(self):
  84.         return (self.left, self.right)
  85.  
  86.     
  87.     def getChildNodes(self):
  88.         return (self.left, self.right)
  89.  
  90.     
  91.     def __repr__(self):
  92.         return 'Add((%s, %s))' % (repr(self.left), repr(self.right))
  93.  
  94.  
  95.  
  96. class And(Node):
  97.     
  98.     def __init__(self, nodes, lineno = None):
  99.         self.nodes = nodes
  100.         self.lineno = lineno
  101.  
  102.     
  103.     def getChildren(self):
  104.         return tuple(flatten(self.nodes))
  105.  
  106.     
  107.     def getChildNodes(self):
  108.         nodelist = []
  109.         nodelist.extend(flatten_nodes(self.nodes))
  110.         return tuple(nodelist)
  111.  
  112.     
  113.     def __repr__(self):
  114.         return 'And(%s)' % (repr(self.nodes),)
  115.  
  116.  
  117.  
  118. class AssAttr(Node):
  119.     
  120.     def __init__(self, expr, attrname, flags, lineno = None):
  121.         self.expr = expr
  122.         self.attrname = attrname
  123.         self.flags = flags
  124.         self.lineno = lineno
  125.  
  126.     
  127.     def getChildren(self):
  128.         return (self.expr, self.attrname, self.flags)
  129.  
  130.     
  131.     def getChildNodes(self):
  132.         return (self.expr,)
  133.  
  134.     
  135.     def __repr__(self):
  136.         return 'AssAttr(%s, %s, %s)' % (repr(self.expr), repr(self.attrname), repr(self.flags))
  137.  
  138.  
  139.  
  140. class AssList(Node):
  141.     
  142.     def __init__(self, nodes, lineno = None):
  143.         self.nodes = nodes
  144.         self.lineno = lineno
  145.  
  146.     
  147.     def getChildren(self):
  148.         return tuple(flatten(self.nodes))
  149.  
  150.     
  151.     def getChildNodes(self):
  152.         nodelist = []
  153.         nodelist.extend(flatten_nodes(self.nodes))
  154.         return tuple(nodelist)
  155.  
  156.     
  157.     def __repr__(self):
  158.         return 'AssList(%s)' % (repr(self.nodes),)
  159.  
  160.  
  161.  
  162. class AssName(Node):
  163.     
  164.     def __init__(self, name, flags, lineno = None):
  165.         self.name = name
  166.         self.flags = flags
  167.         self.lineno = lineno
  168.  
  169.     
  170.     def getChildren(self):
  171.         return (self.name, self.flags)
  172.  
  173.     
  174.     def getChildNodes(self):
  175.         return ()
  176.  
  177.     
  178.     def __repr__(self):
  179.         return 'AssName(%s, %s)' % (repr(self.name), repr(self.flags))
  180.  
  181.  
  182.  
  183. class AssTuple(Node):
  184.     
  185.     def __init__(self, nodes, lineno = None):
  186.         self.nodes = nodes
  187.         self.lineno = lineno
  188.  
  189.     
  190.     def getChildren(self):
  191.         return tuple(flatten(self.nodes))
  192.  
  193.     
  194.     def getChildNodes(self):
  195.         nodelist = []
  196.         nodelist.extend(flatten_nodes(self.nodes))
  197.         return tuple(nodelist)
  198.  
  199.     
  200.     def __repr__(self):
  201.         return 'AssTuple(%s)' % (repr(self.nodes),)
  202.  
  203.  
  204.  
  205. class Assert(Node):
  206.     
  207.     def __init__(self, test, fail, lineno = None):
  208.         self.test = test
  209.         self.fail = fail
  210.         self.lineno = lineno
  211.  
  212.     
  213.     def getChildren(self):
  214.         children = []
  215.         children.append(self.test)
  216.         children.append(self.fail)
  217.         return tuple(children)
  218.  
  219.     
  220.     def getChildNodes(self):
  221.         nodelist = []
  222.         nodelist.append(self.test)
  223.         if self.fail is not None:
  224.             nodelist.append(self.fail)
  225.         
  226.         return tuple(nodelist)
  227.  
  228.     
  229.     def __repr__(self):
  230.         return 'Assert(%s, %s)' % (repr(self.test), repr(self.fail))
  231.  
  232.  
  233.  
  234. class Assign(Node):
  235.     
  236.     def __init__(self, nodes, expr, lineno = None):
  237.         self.nodes = nodes
  238.         self.expr = expr
  239.         self.lineno = lineno
  240.  
  241.     
  242.     def getChildren(self):
  243.         children = []
  244.         children.extend(flatten(self.nodes))
  245.         children.append(self.expr)
  246.         return tuple(children)
  247.  
  248.     
  249.     def getChildNodes(self):
  250.         nodelist = []
  251.         nodelist.extend(flatten_nodes(self.nodes))
  252.         nodelist.append(self.expr)
  253.         return tuple(nodelist)
  254.  
  255.     
  256.     def __repr__(self):
  257.         return 'Assign(%s, %s)' % (repr(self.nodes), repr(self.expr))
  258.  
  259.  
  260.  
  261. class AugAssign(Node):
  262.     
  263.     def __init__(self, node, op, expr, lineno = None):
  264.         self.node = node
  265.         self.op = op
  266.         self.expr = expr
  267.         self.lineno = lineno
  268.  
  269.     
  270.     def getChildren(self):
  271.         return (self.node, self.op, self.expr)
  272.  
  273.     
  274.     def getChildNodes(self):
  275.         return (self.node, self.expr)
  276.  
  277.     
  278.     def __repr__(self):
  279.         return 'AugAssign(%s, %s, %s)' % (repr(self.node), repr(self.op), repr(self.expr))
  280.  
  281.  
  282.  
  283. class Backquote(Node):
  284.     
  285.     def __init__(self, expr, lineno = None):
  286.         self.expr = expr
  287.         self.lineno = lineno
  288.  
  289.     
  290.     def getChildren(self):
  291.         return (self.expr,)
  292.  
  293.     
  294.     def getChildNodes(self):
  295.         return (self.expr,)
  296.  
  297.     
  298.     def __repr__(self):
  299.         return 'Backquote(%s)' % (repr(self.expr),)
  300.  
  301.  
  302.  
  303. class Bitand(Node):
  304.     
  305.     def __init__(self, nodes, lineno = None):
  306.         self.nodes = nodes
  307.         self.lineno = lineno
  308.  
  309.     
  310.     def getChildren(self):
  311.         return tuple(flatten(self.nodes))
  312.  
  313.     
  314.     def getChildNodes(self):
  315.         nodelist = []
  316.         nodelist.extend(flatten_nodes(self.nodes))
  317.         return tuple(nodelist)
  318.  
  319.     
  320.     def __repr__(self):
  321.         return 'Bitand(%s)' % (repr(self.nodes),)
  322.  
  323.  
  324.  
  325. class Bitor(Node):
  326.     
  327.     def __init__(self, nodes, lineno = None):
  328.         self.nodes = nodes
  329.         self.lineno = lineno
  330.  
  331.     
  332.     def getChildren(self):
  333.         return tuple(flatten(self.nodes))
  334.  
  335.     
  336.     def getChildNodes(self):
  337.         nodelist = []
  338.         nodelist.extend(flatten_nodes(self.nodes))
  339.         return tuple(nodelist)
  340.  
  341.     
  342.     def __repr__(self):
  343.         return 'Bitor(%s)' % (repr(self.nodes),)
  344.  
  345.  
  346.  
  347. class Bitxor(Node):
  348.     
  349.     def __init__(self, nodes, lineno = None):
  350.         self.nodes = nodes
  351.         self.lineno = lineno
  352.  
  353.     
  354.     def getChildren(self):
  355.         return tuple(flatten(self.nodes))
  356.  
  357.     
  358.     def getChildNodes(self):
  359.         nodelist = []
  360.         nodelist.extend(flatten_nodes(self.nodes))
  361.         return tuple(nodelist)
  362.  
  363.     
  364.     def __repr__(self):
  365.         return 'Bitxor(%s)' % (repr(self.nodes),)
  366.  
  367.  
  368.  
  369. class Break(Node):
  370.     
  371.     def __init__(self, lineno = None):
  372.         self.lineno = lineno
  373.  
  374.     
  375.     def getChildren(self):
  376.         return ()
  377.  
  378.     
  379.     def getChildNodes(self):
  380.         return ()
  381.  
  382.     
  383.     def __repr__(self):
  384.         return 'Break()'
  385.  
  386.  
  387.  
  388. class CallFunc(Node):
  389.     
  390.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno = None):
  391.         self.node = node
  392.         self.args = args
  393.         self.star_args = star_args
  394.         self.dstar_args = dstar_args
  395.         self.lineno = lineno
  396.  
  397.     
  398.     def getChildren(self):
  399.         children = []
  400.         children.append(self.node)
  401.         children.extend(flatten(self.args))
  402.         children.append(self.star_args)
  403.         children.append(self.dstar_args)
  404.         return tuple(children)
  405.  
  406.     
  407.     def getChildNodes(self):
  408.         nodelist = []
  409.         nodelist.append(self.node)
  410.         nodelist.extend(flatten_nodes(self.args))
  411.         if self.star_args is not None:
  412.             nodelist.append(self.star_args)
  413.         
  414.         if self.dstar_args is not None:
  415.             nodelist.append(self.dstar_args)
  416.         
  417.         return tuple(nodelist)
  418.  
  419.     
  420.     def __repr__(self):
  421.         return 'CallFunc(%s, %s, %s, %s)' % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  422.  
  423.  
  424.  
  425. class Class(Node):
  426.     
  427.     def __init__(self, name, bases, doc, code, lineno = None):
  428.         self.name = name
  429.         self.bases = bases
  430.         self.doc = doc
  431.         self.code = code
  432.         self.lineno = lineno
  433.  
  434.     
  435.     def getChildren(self):
  436.         children = []
  437.         children.append(self.name)
  438.         children.extend(flatten(self.bases))
  439.         children.append(self.doc)
  440.         children.append(self.code)
  441.         return tuple(children)
  442.  
  443.     
  444.     def getChildNodes(self):
  445.         nodelist = []
  446.         nodelist.extend(flatten_nodes(self.bases))
  447.         nodelist.append(self.code)
  448.         return tuple(nodelist)
  449.  
  450.     
  451.     def __repr__(self):
  452.         return 'Class(%s, %s, %s, %s)' % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
  453.  
  454.  
  455.  
  456. class Compare(Node):
  457.     
  458.     def __init__(self, expr, ops, lineno = None):
  459.         self.expr = expr
  460.         self.ops = ops
  461.         self.lineno = lineno
  462.  
  463.     
  464.     def getChildren(self):
  465.         children = []
  466.         children.append(self.expr)
  467.         children.extend(flatten(self.ops))
  468.         return tuple(children)
  469.  
  470.     
  471.     def getChildNodes(self):
  472.         nodelist = []
  473.         nodelist.append(self.expr)
  474.         nodelist.extend(flatten_nodes(self.ops))
  475.         return tuple(nodelist)
  476.  
  477.     
  478.     def __repr__(self):
  479.         return 'Compare(%s, %s)' % (repr(self.expr), repr(self.ops))
  480.  
  481.  
  482.  
  483. class Const(Node):
  484.     
  485.     def __init__(self, value, lineno = None):
  486.         self.value = value
  487.         self.lineno = lineno
  488.  
  489.     
  490.     def getChildren(self):
  491.         return (self.value,)
  492.  
  493.     
  494.     def getChildNodes(self):
  495.         return ()
  496.  
  497.     
  498.     def __repr__(self):
  499.         return 'Const(%s)' % (repr(self.value),)
  500.  
  501.  
  502.  
  503. class Continue(Node):
  504.     
  505.     def __init__(self, lineno = None):
  506.         self.lineno = lineno
  507.  
  508.     
  509.     def getChildren(self):
  510.         return ()
  511.  
  512.     
  513.     def getChildNodes(self):
  514.         return ()
  515.  
  516.     
  517.     def __repr__(self):
  518.         return 'Continue()'
  519.  
  520.  
  521.  
  522. class Decorators(Node):
  523.     
  524.     def __init__(self, nodes, lineno = None):
  525.         self.nodes = nodes
  526.         self.lineno = lineno
  527.  
  528.     
  529.     def getChildren(self):
  530.         return tuple(flatten(self.nodes))
  531.  
  532.     
  533.     def getChildNodes(self):
  534.         nodelist = []
  535.         nodelist.extend(flatten_nodes(self.nodes))
  536.         return tuple(nodelist)
  537.  
  538.     
  539.     def __repr__(self):
  540.         return 'Decorators(%s)' % (repr(self.nodes),)
  541.  
  542.  
  543.  
  544. class Dict(Node):
  545.     
  546.     def __init__(self, items, lineno = None):
  547.         self.items = items
  548.         self.lineno = lineno
  549.  
  550.     
  551.     def getChildren(self):
  552.         return tuple(flatten(self.items))
  553.  
  554.     
  555.     def getChildNodes(self):
  556.         nodelist = []
  557.         nodelist.extend(flatten_nodes(self.items))
  558.         return tuple(nodelist)
  559.  
  560.     
  561.     def __repr__(self):
  562.         return 'Dict(%s)' % (repr(self.items),)
  563.  
  564.  
  565.  
  566. class Discard(Node):
  567.     
  568.     def __init__(self, expr, lineno = None):
  569.         self.expr = expr
  570.         self.lineno = lineno
  571.  
  572.     
  573.     def getChildren(self):
  574.         return (self.expr,)
  575.  
  576.     
  577.     def getChildNodes(self):
  578.         return (self.expr,)
  579.  
  580.     
  581.     def __repr__(self):
  582.         return 'Discard(%s)' % (repr(self.expr),)
  583.  
  584.  
  585.  
  586. class Div(Node):
  587.     
  588.     def __init__(self, .2, lineno = None):
  589.         (left, right) = .2
  590.         self.left = left
  591.         self.right = right
  592.         self.lineno = lineno
  593.  
  594.     
  595.     def getChildren(self):
  596.         return (self.left, self.right)
  597.  
  598.     
  599.     def getChildNodes(self):
  600.         return (self.left, self.right)
  601.  
  602.     
  603.     def __repr__(self):
  604.         return 'Div((%s, %s))' % (repr(self.left), repr(self.right))
  605.  
  606.  
  607.  
  608. class Ellipsis(Node):
  609.     
  610.     def __init__(self, lineno = None):
  611.         self.lineno = lineno
  612.  
  613.     
  614.     def getChildren(self):
  615.         return ()
  616.  
  617.     
  618.     def getChildNodes(self):
  619.         return ()
  620.  
  621.     
  622.     def __repr__(self):
  623.         return 'Ellipsis()'
  624.  
  625.  
  626.  
  627. class Exec(Node):
  628.     
  629.     def __init__(self, expr, locals, globals, lineno = None):
  630.         self.expr = expr
  631.         self.locals = locals
  632.         self.globals = globals
  633.         self.lineno = lineno
  634.  
  635.     
  636.     def getChildren(self):
  637.         children = []
  638.         children.append(self.expr)
  639.         children.append(self.locals)
  640.         children.append(self.globals)
  641.         return tuple(children)
  642.  
  643.     
  644.     def getChildNodes(self):
  645.         nodelist = []
  646.         nodelist.append(self.expr)
  647.         if self.locals is not None:
  648.             nodelist.append(self.locals)
  649.         
  650.         if self.globals is not None:
  651.             nodelist.append(self.globals)
  652.         
  653.         return tuple(nodelist)
  654.  
  655.     
  656.     def __repr__(self):
  657.         return 'Exec(%s, %s, %s)' % (repr(self.expr), repr(self.locals), repr(self.globals))
  658.  
  659.  
  660.  
  661. class FloorDiv(Node):
  662.     
  663.     def __init__(self, .2, lineno = None):
  664.         (left, right) = .2
  665.         self.left = left
  666.         self.right = right
  667.         self.lineno = lineno
  668.  
  669.     
  670.     def getChildren(self):
  671.         return (self.left, self.right)
  672.  
  673.     
  674.     def getChildNodes(self):
  675.         return (self.left, self.right)
  676.  
  677.     
  678.     def __repr__(self):
  679.         return 'FloorDiv((%s, %s))' % (repr(self.left), repr(self.right))
  680.  
  681.  
  682.  
  683. class For(Node):
  684.     
  685.     def __init__(self, assign, list, body, else_, lineno = None):
  686.         self.assign = assign
  687.         self.list = list
  688.         self.body = body
  689.         self.else_ = else_
  690.         self.lineno = lineno
  691.  
  692.     
  693.     def getChildren(self):
  694.         children = []
  695.         children.append(self.assign)
  696.         children.append(self.list)
  697.         children.append(self.body)
  698.         children.append(self.else_)
  699.         return tuple(children)
  700.  
  701.     
  702.     def getChildNodes(self):
  703.         nodelist = []
  704.         nodelist.append(self.assign)
  705.         nodelist.append(self.list)
  706.         nodelist.append(self.body)
  707.         if self.else_ is not None:
  708.             nodelist.append(self.else_)
  709.         
  710.         return tuple(nodelist)
  711.  
  712.     
  713.     def __repr__(self):
  714.         return 'For(%s, %s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  715.  
  716.  
  717.  
  718. class From(Node):
  719.     
  720.     def __init__(self, modname, names, lineno = None):
  721.         self.modname = modname
  722.         self.names = names
  723.         self.lineno = lineno
  724.  
  725.     
  726.     def getChildren(self):
  727.         return (self.modname, self.names)
  728.  
  729.     
  730.     def getChildNodes(self):
  731.         return ()
  732.  
  733.     
  734.     def __repr__(self):
  735.         return 'From(%s, %s)' % (repr(self.modname), repr(self.names))
  736.  
  737.  
  738.  
  739. class Function(Node):
  740.     
  741.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno = None):
  742.         self.decorators = decorators
  743.         self.name = name
  744.         self.argnames = argnames
  745.         self.defaults = defaults
  746.         self.flags = flags
  747.         self.doc = doc
  748.         self.code = code
  749.         self.lineno = lineno
  750.         self.varargs = None
  751.         self.kwargs = None
  752.         if flags & CO_VARARGS:
  753.             self.varargs = 1
  754.         
  755.         if flags & CO_VARKEYWORDS:
  756.             self.kwargs = 1
  757.         
  758.  
  759.     
  760.     def getChildren(self):
  761.         children = []
  762.         children.append(self.decorators)
  763.         children.append(self.name)
  764.         children.append(self.argnames)
  765.         children.extend(flatten(self.defaults))
  766.         children.append(self.flags)
  767.         children.append(self.doc)
  768.         children.append(self.code)
  769.         return tuple(children)
  770.  
  771.     
  772.     def getChildNodes(self):
  773.         nodelist = []
  774.         if self.decorators is not None:
  775.             nodelist.append(self.decorators)
  776.         
  777.         nodelist.extend(flatten_nodes(self.defaults))
  778.         nodelist.append(self.code)
  779.         return tuple(nodelist)
  780.  
  781.     
  782.     def __repr__(self):
  783.         return 'Function(%s, %s, %s, %s, %s, %s, %s)' % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  784.  
  785.  
  786.  
  787. class GenExpr(Node):
  788.     
  789.     def __init__(self, code, lineno = None):
  790.         self.code = code
  791.         self.lineno = lineno
  792.         self.argnames = [
  793.             '[outmost-iterable]']
  794.         self.varargs = None
  795.         self.kwargs = None
  796.  
  797.     
  798.     def getChildren(self):
  799.         return (self.code,)
  800.  
  801.     
  802.     def getChildNodes(self):
  803.         return (self.code,)
  804.  
  805.     
  806.     def __repr__(self):
  807.         return 'GenExpr(%s)' % (repr(self.code),)
  808.  
  809.  
  810.  
  811. class GenExprFor(Node):
  812.     
  813.     def __init__(self, assign, iter, ifs, lineno = None):
  814.         self.assign = assign
  815.         self.iter = iter
  816.         self.ifs = ifs
  817.         self.lineno = lineno
  818.         self.is_outmost = False
  819.  
  820.     
  821.     def getChildren(self):
  822.         children = []
  823.         children.append(self.assign)
  824.         children.append(self.iter)
  825.         children.extend(flatten(self.ifs))
  826.         return tuple(children)
  827.  
  828.     
  829.     def getChildNodes(self):
  830.         nodelist = []
  831.         nodelist.append(self.assign)
  832.         nodelist.append(self.iter)
  833.         nodelist.extend(flatten_nodes(self.ifs))
  834.         return tuple(nodelist)
  835.  
  836.     
  837.     def __repr__(self):
  838.         return 'GenExprFor(%s, %s, %s)' % (repr(self.assign), repr(self.iter), repr(self.ifs))
  839.  
  840.  
  841.  
  842. class GenExprIf(Node):
  843.     
  844.     def __init__(self, test, lineno = None):
  845.         self.test = test
  846.         self.lineno = lineno
  847.  
  848.     
  849.     def getChildren(self):
  850.         return (self.test,)
  851.  
  852.     
  853.     def getChildNodes(self):
  854.         return (self.test,)
  855.  
  856.     
  857.     def __repr__(self):
  858.         return 'GenExprIf(%s)' % (repr(self.test),)
  859.  
  860.  
  861.  
  862. class GenExprInner(Node):
  863.     
  864.     def __init__(self, expr, quals, lineno = None):
  865.         self.expr = expr
  866.         self.quals = quals
  867.         self.lineno = lineno
  868.  
  869.     
  870.     def getChildren(self):
  871.         children = []
  872.         children.append(self.expr)
  873.         children.extend(flatten(self.quals))
  874.         return tuple(children)
  875.  
  876.     
  877.     def getChildNodes(self):
  878.         nodelist = []
  879.         nodelist.append(self.expr)
  880.         nodelist.extend(flatten_nodes(self.quals))
  881.         return tuple(nodelist)
  882.  
  883.     
  884.     def __repr__(self):
  885.         return 'GenExprInner(%s, %s)' % (repr(self.expr), repr(self.quals))
  886.  
  887.  
  888.  
  889. class Getattr(Node):
  890.     
  891.     def __init__(self, expr, attrname, lineno = None):
  892.         self.expr = expr
  893.         self.attrname = attrname
  894.         self.lineno = lineno
  895.  
  896.     
  897.     def getChildren(self):
  898.         return (self.expr, self.attrname)
  899.  
  900.     
  901.     def getChildNodes(self):
  902.         return (self.expr,)
  903.  
  904.     
  905.     def __repr__(self):
  906.         return 'Getattr(%s, %s)' % (repr(self.expr), repr(self.attrname))
  907.  
  908.  
  909.  
  910. class Global(Node):
  911.     
  912.     def __init__(self, names, lineno = None):
  913.         self.names = names
  914.         self.lineno = lineno
  915.  
  916.     
  917.     def getChildren(self):
  918.         return (self.names,)
  919.  
  920.     
  921.     def getChildNodes(self):
  922.         return ()
  923.  
  924.     
  925.     def __repr__(self):
  926.         return 'Global(%s)' % (repr(self.names),)
  927.  
  928.  
  929.  
  930. class If(Node):
  931.     
  932.     def __init__(self, tests, else_, lineno = None):
  933.         self.tests = tests
  934.         self.else_ = else_
  935.         self.lineno = lineno
  936.  
  937.     
  938.     def getChildren(self):
  939.         children = []
  940.         children.extend(flatten(self.tests))
  941.         children.append(self.else_)
  942.         return tuple(children)
  943.  
  944.     
  945.     def getChildNodes(self):
  946.         nodelist = []
  947.         nodelist.extend(flatten_nodes(self.tests))
  948.         if self.else_ is not None:
  949.             nodelist.append(self.else_)
  950.         
  951.         return tuple(nodelist)
  952.  
  953.     
  954.     def __repr__(self):
  955.         return 'If(%s, %s)' % (repr(self.tests), repr(self.else_))
  956.  
  957.  
  958.  
  959. class Import(Node):
  960.     
  961.     def __init__(self, names, lineno = None):
  962.         self.names = names
  963.         self.lineno = lineno
  964.  
  965.     
  966.     def getChildren(self):
  967.         return (self.names,)
  968.  
  969.     
  970.     def getChildNodes(self):
  971.         return ()
  972.  
  973.     
  974.     def __repr__(self):
  975.         return 'Import(%s)' % (repr(self.names),)
  976.  
  977.  
  978.  
  979. class Invert(Node):
  980.     
  981.     def __init__(self, expr, lineno = None):
  982.         self.expr = expr
  983.         self.lineno = lineno
  984.  
  985.     
  986.     def getChildren(self):
  987.         return (self.expr,)
  988.  
  989.     
  990.     def getChildNodes(self):
  991.         return (self.expr,)
  992.  
  993.     
  994.     def __repr__(self):
  995.         return 'Invert(%s)' % (repr(self.expr),)
  996.  
  997.  
  998.  
  999. class Keyword(Node):
  1000.     
  1001.     def __init__(self, name, expr, lineno = None):
  1002.         self.name = name
  1003.         self.expr = expr
  1004.         self.lineno = lineno
  1005.  
  1006.     
  1007.     def getChildren(self):
  1008.         return (self.name, self.expr)
  1009.  
  1010.     
  1011.     def getChildNodes(self):
  1012.         return (self.expr,)
  1013.  
  1014.     
  1015.     def __repr__(self):
  1016.         return 'Keyword(%s, %s)' % (repr(self.name), repr(self.expr))
  1017.  
  1018.  
  1019.  
  1020. class Lambda(Node):
  1021.     
  1022.     def __init__(self, argnames, defaults, flags, code, lineno = None):
  1023.         self.argnames = argnames
  1024.         self.defaults = defaults
  1025.         self.flags = flags
  1026.         self.code = code
  1027.         self.lineno = lineno
  1028.         self.varargs = None
  1029.         self.kwargs = None
  1030.         if flags & CO_VARARGS:
  1031.             self.varargs = 1
  1032.         
  1033.         if flags & CO_VARKEYWORDS:
  1034.             self.kwargs = 1
  1035.         
  1036.  
  1037.     
  1038.     def getChildren(self):
  1039.         children = []
  1040.         children.append(self.argnames)
  1041.         children.extend(flatten(self.defaults))
  1042.         children.append(self.flags)
  1043.         children.append(self.code)
  1044.         return tuple(children)
  1045.  
  1046.     
  1047.     def getChildNodes(self):
  1048.         nodelist = []
  1049.         nodelist.extend(flatten_nodes(self.defaults))
  1050.         nodelist.append(self.code)
  1051.         return tuple(nodelist)
  1052.  
  1053.     
  1054.     def __repr__(self):
  1055.         return 'Lambda(%s, %s, %s, %s)' % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  1056.  
  1057.  
  1058.  
  1059. class LeftShift(Node):
  1060.     
  1061.     def __init__(self, .2, lineno = None):
  1062.         (left, right) = .2
  1063.         self.left = left
  1064.         self.right = right
  1065.         self.lineno = lineno
  1066.  
  1067.     
  1068.     def getChildren(self):
  1069.         return (self.left, self.right)
  1070.  
  1071.     
  1072.     def getChildNodes(self):
  1073.         return (self.left, self.right)
  1074.  
  1075.     
  1076.     def __repr__(self):
  1077.         return 'LeftShift((%s, %s))' % (repr(self.left), repr(self.right))
  1078.  
  1079.  
  1080.  
  1081. class List(Node):
  1082.     
  1083.     def __init__(self, nodes, lineno = None):
  1084.         self.nodes = nodes
  1085.         self.lineno = lineno
  1086.  
  1087.     
  1088.     def getChildren(self):
  1089.         return tuple(flatten(self.nodes))
  1090.  
  1091.     
  1092.     def getChildNodes(self):
  1093.         nodelist = []
  1094.         nodelist.extend(flatten_nodes(self.nodes))
  1095.         return tuple(nodelist)
  1096.  
  1097.     
  1098.     def __repr__(self):
  1099.         return 'List(%s)' % (repr(self.nodes),)
  1100.  
  1101.  
  1102.  
  1103. class ListComp(Node):
  1104.     
  1105.     def __init__(self, expr, quals, lineno = None):
  1106.         self.expr = expr
  1107.         self.quals = quals
  1108.         self.lineno = lineno
  1109.  
  1110.     
  1111.     def getChildren(self):
  1112.         children = []
  1113.         children.append(self.expr)
  1114.         children.extend(flatten(self.quals))
  1115.         return tuple(children)
  1116.  
  1117.     
  1118.     def getChildNodes(self):
  1119.         nodelist = []
  1120.         nodelist.append(self.expr)
  1121.         nodelist.extend(flatten_nodes(self.quals))
  1122.         return tuple(nodelist)
  1123.  
  1124.     
  1125.     def __repr__(self):
  1126.         return 'ListComp(%s, %s)' % (repr(self.expr), repr(self.quals))
  1127.  
  1128.  
  1129.  
  1130. class ListCompFor(Node):
  1131.     
  1132.     def __init__(self, assign, list, ifs, lineno = None):
  1133.         self.assign = assign
  1134.         self.list = list
  1135.         self.ifs = ifs
  1136.         self.lineno = lineno
  1137.  
  1138.     
  1139.     def getChildren(self):
  1140.         children = []
  1141.         children.append(self.assign)
  1142.         children.append(self.list)
  1143.         children.extend(flatten(self.ifs))
  1144.         return tuple(children)
  1145.  
  1146.     
  1147.     def getChildNodes(self):
  1148.         nodelist = []
  1149.         nodelist.append(self.assign)
  1150.         nodelist.append(self.list)
  1151.         nodelist.extend(flatten_nodes(self.ifs))
  1152.         return tuple(nodelist)
  1153.  
  1154.     
  1155.     def __repr__(self):
  1156.         return 'ListCompFor(%s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.ifs))
  1157.  
  1158.  
  1159.  
  1160. class ListCompIf(Node):
  1161.     
  1162.     def __init__(self, test, lineno = None):
  1163.         self.test = test
  1164.         self.lineno = lineno
  1165.  
  1166.     
  1167.     def getChildren(self):
  1168.         return (self.test,)
  1169.  
  1170.     
  1171.     def getChildNodes(self):
  1172.         return (self.test,)
  1173.  
  1174.     
  1175.     def __repr__(self):
  1176.         return 'ListCompIf(%s)' % (repr(self.test),)
  1177.  
  1178.  
  1179.  
  1180. class Mod(Node):
  1181.     
  1182.     def __init__(self, .2, lineno = None):
  1183.         (left, right) = .2
  1184.         self.left = left
  1185.         self.right = right
  1186.         self.lineno = lineno
  1187.  
  1188.     
  1189.     def getChildren(self):
  1190.         return (self.left, self.right)
  1191.  
  1192.     
  1193.     def getChildNodes(self):
  1194.         return (self.left, self.right)
  1195.  
  1196.     
  1197.     def __repr__(self):
  1198.         return 'Mod((%s, %s))' % (repr(self.left), repr(self.right))
  1199.  
  1200.  
  1201.  
  1202. class Module(Node):
  1203.     
  1204.     def __init__(self, doc, node, lineno = None):
  1205.         self.doc = doc
  1206.         self.node = node
  1207.         self.lineno = lineno
  1208.  
  1209.     
  1210.     def getChildren(self):
  1211.         return (self.doc, self.node)
  1212.  
  1213.     
  1214.     def getChildNodes(self):
  1215.         return (self.node,)
  1216.  
  1217.     
  1218.     def __repr__(self):
  1219.         return 'Module(%s, %s)' % (repr(self.doc), repr(self.node))
  1220.  
  1221.  
  1222.  
  1223. class Mul(Node):
  1224.     
  1225.     def __init__(self, .2, lineno = None):
  1226.         (left, right) = .2
  1227.         self.left = left
  1228.         self.right = right
  1229.         self.lineno = lineno
  1230.  
  1231.     
  1232.     def getChildren(self):
  1233.         return (self.left, self.right)
  1234.  
  1235.     
  1236.     def getChildNodes(self):
  1237.         return (self.left, self.right)
  1238.  
  1239.     
  1240.     def __repr__(self):
  1241.         return 'Mul((%s, %s))' % (repr(self.left), repr(self.right))
  1242.  
  1243.  
  1244.  
  1245. class Name(Node):
  1246.     
  1247.     def __init__(self, name, lineno = None):
  1248.         self.name = name
  1249.         self.lineno = lineno
  1250.  
  1251.     
  1252.     def getChildren(self):
  1253.         return (self.name,)
  1254.  
  1255.     
  1256.     def getChildNodes(self):
  1257.         return ()
  1258.  
  1259.     
  1260.     def __repr__(self):
  1261.         return 'Name(%s)' % (repr(self.name),)
  1262.  
  1263.  
  1264.  
  1265. class Not(Node):
  1266.     
  1267.     def __init__(self, expr, lineno = None):
  1268.         self.expr = expr
  1269.         self.lineno = lineno
  1270.  
  1271.     
  1272.     def getChildren(self):
  1273.         return (self.expr,)
  1274.  
  1275.     
  1276.     def getChildNodes(self):
  1277.         return (self.expr,)
  1278.  
  1279.     
  1280.     def __repr__(self):
  1281.         return 'Not(%s)' % (repr(self.expr),)
  1282.  
  1283.  
  1284.  
  1285. class Or(Node):
  1286.     
  1287.     def __init__(self, nodes, lineno = None):
  1288.         self.nodes = nodes
  1289.         self.lineno = lineno
  1290.  
  1291.     
  1292.     def getChildren(self):
  1293.         return tuple(flatten(self.nodes))
  1294.  
  1295.     
  1296.     def getChildNodes(self):
  1297.         nodelist = []
  1298.         nodelist.extend(flatten_nodes(self.nodes))
  1299.         return tuple(nodelist)
  1300.  
  1301.     
  1302.     def __repr__(self):
  1303.         return 'Or(%s)' % (repr(self.nodes),)
  1304.  
  1305.  
  1306.  
  1307. class Pass(Node):
  1308.     
  1309.     def __init__(self, lineno = None):
  1310.         self.lineno = lineno
  1311.  
  1312.     
  1313.     def getChildren(self):
  1314.         return ()
  1315.  
  1316.     
  1317.     def getChildNodes(self):
  1318.         return ()
  1319.  
  1320.     
  1321.     def __repr__(self):
  1322.         return 'Pass()'
  1323.  
  1324.  
  1325.  
  1326. class Power(Node):
  1327.     
  1328.     def __init__(self, .2, lineno = None):
  1329.         (left, right) = .2
  1330.         self.left = left
  1331.         self.right = right
  1332.         self.lineno = lineno
  1333.  
  1334.     
  1335.     def getChildren(self):
  1336.         return (self.left, self.right)
  1337.  
  1338.     
  1339.     def getChildNodes(self):
  1340.         return (self.left, self.right)
  1341.  
  1342.     
  1343.     def __repr__(self):
  1344.         return 'Power((%s, %s))' % (repr(self.left), repr(self.right))
  1345.  
  1346.  
  1347.  
  1348. class Print(Node):
  1349.     
  1350.     def __init__(self, nodes, dest, lineno = None):
  1351.         self.nodes = nodes
  1352.         self.dest = dest
  1353.         self.lineno = lineno
  1354.  
  1355.     
  1356.     def getChildren(self):
  1357.         children = []
  1358.         children.extend(flatten(self.nodes))
  1359.         children.append(self.dest)
  1360.         return tuple(children)
  1361.  
  1362.     
  1363.     def getChildNodes(self):
  1364.         nodelist = []
  1365.         nodelist.extend(flatten_nodes(self.nodes))
  1366.         if self.dest is not None:
  1367.             nodelist.append(self.dest)
  1368.         
  1369.         return tuple(nodelist)
  1370.  
  1371.     
  1372.     def __repr__(self):
  1373.         return 'Print(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1374.  
  1375.  
  1376.  
  1377. class Printnl(Node):
  1378.     
  1379.     def __init__(self, nodes, dest, lineno = None):
  1380.         self.nodes = nodes
  1381.         self.dest = dest
  1382.         self.lineno = lineno
  1383.  
  1384.     
  1385.     def getChildren(self):
  1386.         children = []
  1387.         children.extend(flatten(self.nodes))
  1388.         children.append(self.dest)
  1389.         return tuple(children)
  1390.  
  1391.     
  1392.     def getChildNodes(self):
  1393.         nodelist = []
  1394.         nodelist.extend(flatten_nodes(self.nodes))
  1395.         if self.dest is not None:
  1396.             nodelist.append(self.dest)
  1397.         
  1398.         return tuple(nodelist)
  1399.  
  1400.     
  1401.     def __repr__(self):
  1402.         return 'Printnl(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1403.  
  1404.  
  1405.  
  1406. class Raise(Node):
  1407.     
  1408.     def __init__(self, expr1, expr2, expr3, lineno = None):
  1409.         self.expr1 = expr1
  1410.         self.expr2 = expr2
  1411.         self.expr3 = expr3
  1412.         self.lineno = lineno
  1413.  
  1414.     
  1415.     def getChildren(self):
  1416.         children = []
  1417.         children.append(self.expr1)
  1418.         children.append(self.expr2)
  1419.         children.append(self.expr3)
  1420.         return tuple(children)
  1421.  
  1422.     
  1423.     def getChildNodes(self):
  1424.         nodelist = []
  1425.         if self.expr1 is not None:
  1426.             nodelist.append(self.expr1)
  1427.         
  1428.         if self.expr2 is not None:
  1429.             nodelist.append(self.expr2)
  1430.         
  1431.         if self.expr3 is not None:
  1432.             nodelist.append(self.expr3)
  1433.         
  1434.         return tuple(nodelist)
  1435.  
  1436.     
  1437.     def __repr__(self):
  1438.         return 'Raise(%s, %s, %s)' % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1439.  
  1440.  
  1441.  
  1442. class Return(Node):
  1443.     
  1444.     def __init__(self, value, lineno = None):
  1445.         self.value = value
  1446.         self.lineno = lineno
  1447.  
  1448.     
  1449.     def getChildren(self):
  1450.         return (self.value,)
  1451.  
  1452.     
  1453.     def getChildNodes(self):
  1454.         return (self.value,)
  1455.  
  1456.     
  1457.     def __repr__(self):
  1458.         return 'Return(%s)' % (repr(self.value),)
  1459.  
  1460.  
  1461.  
  1462. class RightShift(Node):
  1463.     
  1464.     def __init__(self, .2, lineno = None):
  1465.         (left, right) = .2
  1466.         self.left = left
  1467.         self.right = right
  1468.         self.lineno = lineno
  1469.  
  1470.     
  1471.     def getChildren(self):
  1472.         return (self.left, self.right)
  1473.  
  1474.     
  1475.     def getChildNodes(self):
  1476.         return (self.left, self.right)
  1477.  
  1478.     
  1479.     def __repr__(self):
  1480.         return 'RightShift((%s, %s))' % (repr(self.left), repr(self.right))
  1481.  
  1482.  
  1483.  
  1484. class Slice(Node):
  1485.     
  1486.     def __init__(self, expr, flags, lower, upper, lineno = None):
  1487.         self.expr = expr
  1488.         self.flags = flags
  1489.         self.lower = lower
  1490.         self.upper = upper
  1491.         self.lineno = lineno
  1492.  
  1493.     
  1494.     def getChildren(self):
  1495.         children = []
  1496.         children.append(self.expr)
  1497.         children.append(self.flags)
  1498.         children.append(self.lower)
  1499.         children.append(self.upper)
  1500.         return tuple(children)
  1501.  
  1502.     
  1503.     def getChildNodes(self):
  1504.         nodelist = []
  1505.         nodelist.append(self.expr)
  1506.         if self.lower is not None:
  1507.             nodelist.append(self.lower)
  1508.         
  1509.         if self.upper is not None:
  1510.             nodelist.append(self.upper)
  1511.         
  1512.         return tuple(nodelist)
  1513.  
  1514.     
  1515.     def __repr__(self):
  1516.         return 'Slice(%s, %s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1517.  
  1518.  
  1519.  
  1520. class Sliceobj(Node):
  1521.     
  1522.     def __init__(self, nodes, lineno = None):
  1523.         self.nodes = nodes
  1524.         self.lineno = lineno
  1525.  
  1526.     
  1527.     def getChildren(self):
  1528.         return tuple(flatten(self.nodes))
  1529.  
  1530.     
  1531.     def getChildNodes(self):
  1532.         nodelist = []
  1533.         nodelist.extend(flatten_nodes(self.nodes))
  1534.         return tuple(nodelist)
  1535.  
  1536.     
  1537.     def __repr__(self):
  1538.         return 'Sliceobj(%s)' % (repr(self.nodes),)
  1539.  
  1540.  
  1541.  
  1542. class Stmt(Node):
  1543.     
  1544.     def __init__(self, nodes, lineno = None):
  1545.         self.nodes = nodes
  1546.         self.lineno = lineno
  1547.  
  1548.     
  1549.     def getChildren(self):
  1550.         return tuple(flatten(self.nodes))
  1551.  
  1552.     
  1553.     def getChildNodes(self):
  1554.         nodelist = []
  1555.         nodelist.extend(flatten_nodes(self.nodes))
  1556.         return tuple(nodelist)
  1557.  
  1558.     
  1559.     def __repr__(self):
  1560.         return 'Stmt(%s)' % (repr(self.nodes),)
  1561.  
  1562.  
  1563.  
  1564. class Sub(Node):
  1565.     
  1566.     def __init__(self, .2, lineno = None):
  1567.         (left, right) = .2
  1568.         self.left = left
  1569.         self.right = right
  1570.         self.lineno = lineno
  1571.  
  1572.     
  1573.     def getChildren(self):
  1574.         return (self.left, self.right)
  1575.  
  1576.     
  1577.     def getChildNodes(self):
  1578.         return (self.left, self.right)
  1579.  
  1580.     
  1581.     def __repr__(self):
  1582.         return 'Sub((%s, %s))' % (repr(self.left), repr(self.right))
  1583.  
  1584.  
  1585.  
  1586. class Subscript(Node):
  1587.     
  1588.     def __init__(self, expr, flags, subs, lineno = None):
  1589.         self.expr = expr
  1590.         self.flags = flags
  1591.         self.subs = subs
  1592.         self.lineno = lineno
  1593.  
  1594.     
  1595.     def getChildren(self):
  1596.         children = []
  1597.         children.append(self.expr)
  1598.         children.append(self.flags)
  1599.         children.extend(flatten(self.subs))
  1600.         return tuple(children)
  1601.  
  1602.     
  1603.     def getChildNodes(self):
  1604.         nodelist = []
  1605.         nodelist.append(self.expr)
  1606.         nodelist.extend(flatten_nodes(self.subs))
  1607.         return tuple(nodelist)
  1608.  
  1609.     
  1610.     def __repr__(self):
  1611.         return 'Subscript(%s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.subs))
  1612.  
  1613.  
  1614.  
  1615. class TryExcept(Node):
  1616.     
  1617.     def __init__(self, body, handlers, else_, lineno = None):
  1618.         self.body = body
  1619.         self.handlers = handlers
  1620.         self.else_ = else_
  1621.         self.lineno = lineno
  1622.  
  1623.     
  1624.     def getChildren(self):
  1625.         children = []
  1626.         children.append(self.body)
  1627.         children.extend(flatten(self.handlers))
  1628.         children.append(self.else_)
  1629.         return tuple(children)
  1630.  
  1631.     
  1632.     def getChildNodes(self):
  1633.         nodelist = []
  1634.         nodelist.append(self.body)
  1635.         nodelist.extend(flatten_nodes(self.handlers))
  1636.         if self.else_ is not None:
  1637.             nodelist.append(self.else_)
  1638.         
  1639.         return tuple(nodelist)
  1640.  
  1641.     
  1642.     def __repr__(self):
  1643.         return 'TryExcept(%s, %s, %s)' % (repr(self.body), repr(self.handlers), repr(self.else_))
  1644.  
  1645.  
  1646.  
  1647. class TryFinally(Node):
  1648.     
  1649.     def __init__(self, body, final, lineno = None):
  1650.         self.body = body
  1651.         self.final = final
  1652.         self.lineno = lineno
  1653.  
  1654.     
  1655.     def getChildren(self):
  1656.         return (self.body, self.final)
  1657.  
  1658.     
  1659.     def getChildNodes(self):
  1660.         return (self.body, self.final)
  1661.  
  1662.     
  1663.     def __repr__(self):
  1664.         return 'TryFinally(%s, %s)' % (repr(self.body), repr(self.final))
  1665.  
  1666.  
  1667.  
  1668. class Tuple(Node):
  1669.     
  1670.     def __init__(self, nodes, lineno = None):
  1671.         self.nodes = nodes
  1672.         self.lineno = lineno
  1673.  
  1674.     
  1675.     def getChildren(self):
  1676.         return tuple(flatten(self.nodes))
  1677.  
  1678.     
  1679.     def getChildNodes(self):
  1680.         nodelist = []
  1681.         nodelist.extend(flatten_nodes(self.nodes))
  1682.         return tuple(nodelist)
  1683.  
  1684.     
  1685.     def __repr__(self):
  1686.         return 'Tuple(%s)' % (repr(self.nodes),)
  1687.  
  1688.  
  1689.  
  1690. class UnaryAdd(Node):
  1691.     
  1692.     def __init__(self, expr, lineno = None):
  1693.         self.expr = expr
  1694.         self.lineno = lineno
  1695.  
  1696.     
  1697.     def getChildren(self):
  1698.         return (self.expr,)
  1699.  
  1700.     
  1701.     def getChildNodes(self):
  1702.         return (self.expr,)
  1703.  
  1704.     
  1705.     def __repr__(self):
  1706.         return 'UnaryAdd(%s)' % (repr(self.expr),)
  1707.  
  1708.  
  1709.  
  1710. class UnarySub(Node):
  1711.     
  1712.     def __init__(self, expr, lineno = None):
  1713.         self.expr = expr
  1714.         self.lineno = lineno
  1715.  
  1716.     
  1717.     def getChildren(self):
  1718.         return (self.expr,)
  1719.  
  1720.     
  1721.     def getChildNodes(self):
  1722.         return (self.expr,)
  1723.  
  1724.     
  1725.     def __repr__(self):
  1726.         return 'UnarySub(%s)' % (repr(self.expr),)
  1727.  
  1728.  
  1729.  
  1730. class While(Node):
  1731.     
  1732.     def __init__(self, test, body, else_, lineno = None):
  1733.         self.test = test
  1734.         self.body = body
  1735.         self.else_ = else_
  1736.         self.lineno = lineno
  1737.  
  1738.     
  1739.     def getChildren(self):
  1740.         children = []
  1741.         children.append(self.test)
  1742.         children.append(self.body)
  1743.         children.append(self.else_)
  1744.         return tuple(children)
  1745.  
  1746.     
  1747.     def getChildNodes(self):
  1748.         nodelist = []
  1749.         nodelist.append(self.test)
  1750.         nodelist.append(self.body)
  1751.         if self.else_ is not None:
  1752.             nodelist.append(self.else_)
  1753.         
  1754.         return tuple(nodelist)
  1755.  
  1756.     
  1757.     def __repr__(self):
  1758.         return 'While(%s, %s, %s)' % (repr(self.test), repr(self.body), repr(self.else_))
  1759.  
  1760.  
  1761.  
  1762. class Yield(Node):
  1763.     
  1764.     def __init__(self, value, lineno = None):
  1765.         self.value = value
  1766.         self.lineno = lineno
  1767.  
  1768.     
  1769.     def getChildren(self):
  1770.         return (self.value,)
  1771.  
  1772.     
  1773.     def getChildNodes(self):
  1774.         return (self.value,)
  1775.  
  1776.     
  1777.     def __repr__(self):
  1778.         return 'Yield(%s)' % (repr(self.value),)
  1779.  
  1780.  
  1781. for name, obj in globals().items():
  1782.     if isinstance(obj, type) and issubclass(obj, Node):
  1783.         nodes[name.lower()] = obj
  1784.         continue
  1785.  
  1786.